﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Sql;


namespace ASPNETVN.PORTAL.Components.Share
{
    public partial class Attachment
    {
        #region Properties.

        public int ID { set; get; }
        public Guid ModuleID { set; get; }
        public int ItemID { set; get; }
        public string FileName { set; get; }
        public string FileUrl { set; get; }
        public long FileSize { set; get; }
        public string ContentType { set; get; }
        public string StorageType { set; get; }
        public byte[] BinaryContent { set; get; }

        #endregion

        //---------------------------------------------------------------------------------------------

        #region Select methods.

        public static Attachment Load(int id)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_Load]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@ID", SqlDbType.Int, id);
            Attachment entity = null;
            IDataReader reader = db.ExecuteReader(dbCommand);
            if (reader.Read())
            {
                entity = new Attachment();
                if (!reader.IsDBNull(reader.GetOrdinal("ID"))) entity.ID = reader.GetInt32(reader.GetOrdinal("ID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ModuleID"))) entity.ModuleID = reader.GetGuid(reader.GetOrdinal("ModuleID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ItemID"))) entity.ItemID = reader.GetInt32(reader.GetOrdinal("ItemID"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileName"))) entity.FileName = reader.GetString(reader.GetOrdinal("FileName"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileUrl"))) entity.FileUrl = reader.GetString(reader.GetOrdinal("FileUrl"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileSize"))) entity.FileSize = reader.GetInt64(reader.GetOrdinal("FileSize"));
                if (!reader.IsDBNull(reader.GetOrdinal("ContentType"))) entity.ContentType = reader.GetString(reader.GetOrdinal("ContentType"));
                if (!reader.IsDBNull(reader.GetOrdinal("StorageType"))) entity.StorageType = reader.GetString(reader.GetOrdinal("StorageType"));
                if (!reader.IsDBNull(reader.GetOrdinal("BinaryContent"))) entity.BinaryContent = (byte[])reader["BinaryContent"];
            }
            reader.Close();
            return entity;
        }

        //---------------------------------------------------------------------------------------------
        public static List<Attachment> SelectCollectionAll(Guid moduleID)
        {
            List<Attachment> collection = new List<Attachment>();
            SqlDataReader reader = (SqlDataReader)SelectReaderAll(moduleID);
            while (reader.Read())
            {
                Attachment entity = new Attachment();

                if (!reader.IsDBNull(reader.GetOrdinal("ID"))) entity.ID = reader.GetInt32(reader.GetOrdinal("ID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ModuleID"))) entity.ModuleID = reader.GetGuid(reader.GetOrdinal("ModuleID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ItemID"))) entity.ItemID = reader.GetInt32(reader.GetOrdinal("ItemID"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileName"))) entity.FileName = reader.GetString(reader.GetOrdinal("FileName"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileUrl"))) entity.FileUrl = reader.GetString(reader.GetOrdinal("FileUrl"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileSize"))) entity.FileSize = reader.GetInt64(reader.GetOrdinal("FileSize"));
                if (!reader.IsDBNull(reader.GetOrdinal("ContentType"))) entity.ContentType = reader.GetString(reader.GetOrdinal("ContentType"));
                if (!reader.IsDBNull(reader.GetOrdinal("StorageType"))) entity.StorageType = reader.GetString(reader.GetOrdinal("StorageType"));
                if (!reader.IsDBNull(reader.GetOrdinal("BinaryContent"))) entity.BinaryContent = (byte[])reader["BinaryContent"];
                collection.Add(entity);
            }

            reader.Close();
            return collection;
        }

        //---------------------------------------------------------------------------------------------

        public static List<Attachment> SelectCollectionDynamic(string whereCondition, string orderByExpression)
        {
            List<Attachment> collection = new List<Attachment>();

            SqlDataReader reader = (SqlDataReader)SelectReaderDynamic(whereCondition, orderByExpression);
            while (reader.Read())
            {
                Attachment entity = new Attachment();

                if (!reader.IsDBNull(reader.GetOrdinal("ID"))) entity.ID = reader.GetInt32(reader.GetOrdinal("ID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ModuleID"))) entity.ModuleID = reader.GetGuid(reader.GetOrdinal("ModuleID"));
                if (!reader.IsDBNull(reader.GetOrdinal("ItemID"))) entity.ItemID = reader.GetInt32(reader.GetOrdinal("ItemID"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileName"))) entity.FileName = reader.GetString(reader.GetOrdinal("FileName"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileUrl"))) entity.FileUrl = reader.GetString(reader.GetOrdinal("FileUrl"));
                if (!reader.IsDBNull(reader.GetOrdinal("FileSize"))) entity.FileSize = reader.GetInt64(reader.GetOrdinal("FileSize"));
                if (!reader.IsDBNull(reader.GetOrdinal("ContentType"))) entity.ContentType = reader.GetString(reader.GetOrdinal("ContentType"));
                if (!reader.IsDBNull(reader.GetOrdinal("StorageType"))) entity.StorageType = reader.GetString(reader.GetOrdinal("StorageType"));
                if (!reader.IsDBNull(reader.GetOrdinal("BinaryContent"))) entity.BinaryContent = (byte[])reader["BinaryContent"];
                collection.Add(entity);
            }

            reader.Close();
            return collection;
        }

        //---------------------------------------------------------------------------------------------

        // Select by foreign key return collection		


        public static DataSet SelectAll(Guid moduleID)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_SelectAll]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@ModuleID", SqlDbType.UniqueIdentifier, moduleID);
            return db.ExecuteDataSet(dbCommand);
        }

        //---------------------------------------------------------------------------------------------

        public static DataSet SelectDynamic(string whereCondition, string orderByExpression)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_SelectDynamic]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@WhereCondition", SqlDbType.NVarChar, whereCondition);
            db.AddInParameter(dbCommand, "@OrderByExpression", SqlDbType.NVarChar, orderByExpression);

            return db.ExecuteDataSet(dbCommand);
        }

        //---------------------------------------------------------------------------------------------

        public static IDataReader SelectReaderAll(Guid moduleID)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_SelectAll]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);
            db.AddInParameter(dbCommand, "@ModuleID", SqlDbType.UniqueIdentifier, moduleID);
            return db.ExecuteReader(dbCommand);
        }

        //---------------------------------------------------------------------------------------------

        public static IDataReader SelectReaderDynamic(string whereCondition, string orderByExpression)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_SelectDynamic]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@WhereCondition", SqlDbType.NVarChar, whereCondition);
            db.AddInParameter(dbCommand, "@OrderByExpression", SqlDbType.NVarChar, orderByExpression);

            return db.ExecuteReader(dbCommand);
        }

        //---------------------------------------------------------------------------------------------

        // Select by foreign key return collection		

        #endregion

        //---------------------------------------------------------------------------------------------

        #region Insert methods.

        public static int InsertAttachment(Guid moduleID, int itemID, string fileName, string fileUrl, long fileSize, string contentType, string storageType, byte[] binaryContent)
        {
            Attachment entity = new Attachment();
            entity.ModuleID = moduleID;
            entity.ItemID = itemID;
            entity.FileName = fileName;
            entity.FileUrl = fileUrl;
            entity.FileSize = fileSize;
            entity.ContentType = contentType;
            entity.StorageType = storageType;
            entity.BinaryContent = binaryContent;
            return entity.Insert();
        }

        public int Insert()
        {
            return this.Insert(null);
        }

        //---------------------------------------------------------------------------------------------

        public int Insert(SqlTransaction transaction)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_Insert]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddOutParameter(dbCommand, "@ID", SqlDbType.Int, 4);
            db.AddInParameter(dbCommand, "@ModuleID", SqlDbType.UniqueIdentifier, ModuleID);
            db.AddInParameter(dbCommand, "@ItemID", SqlDbType.Int, ItemID);
            db.AddInParameter(dbCommand, "@FileName", SqlDbType.NVarChar, FileName);
            db.AddInParameter(dbCommand, "@FileUrl", SqlDbType.NVarChar, FileUrl);
            db.AddInParameter(dbCommand, "@FileSize", SqlDbType.BigInt, FileSize);
            db.AddInParameter(dbCommand, "@ContentType", SqlDbType.VarChar, ContentType);
            db.AddInParameter(dbCommand, "@StorageType", SqlDbType.VarChar, StorageType);
            db.AddInParameter(dbCommand, "@BinaryContent", SqlDbType.VarBinary, BinaryContent);

            if (transaction != null)
            {
                db.ExecuteNonQuery(dbCommand, transaction);
                ID = (int)db.GetParameterValue(dbCommand, "@ID");
                return ID;
            }
            else
            {
                db.ExecuteNonQuery(dbCommand);
                ID = (int)db.GetParameterValue(dbCommand, "@ID");
                return ID;
            }
        }

        //---------------------------------------------------------------------------------------------
        public static bool InsertCollection(IList<Attachment> collection)
        {
            bool ret;
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            using (SqlConnection connection = (SqlConnection)db.CreateConnection())
            {
                connection.Open();
                using (SqlTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        bool ret01 = true;
                        foreach (Attachment item in collection)
                        {
                            if (item.Insert(transaction) <= 0)
                            {
                                ret01 = false;
                                break;
                            }
                        }
                        if (ret01)
                        {
                            transaction.Commit();
                            ret = true;
                        }
                        else
                        {
                            transaction.Rollback();
                            ret = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw new Exception("Error at InsertCollection method: " + ex.Message);
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
            return ret;
        }

        #endregion

        //---------------------------------------------------------------------------------------------

        #region Insert / Update methods.

        public static int InsertUpdateAttachment(int id, Guid moduleID, int itemID, string fileName, string fileUrl, long fileSize, string contentType, string storageType, byte[] binaryContent)
        {
            Attachment entity = new Attachment();
            entity.ID = id;
            entity.ModuleID = moduleID;
            entity.ItemID = itemID;
            entity.FileName = fileName;
            entity.FileUrl = fileUrl;
            entity.FileSize = fileSize;
            entity.ContentType = contentType;
            entity.StorageType = storageType;
            entity.BinaryContent = binaryContent;
            return entity.InsertUpdate();
        }

        //---------------------------------------------------------------------------------------------

        public int InsertUpdate()
        {
            return this.InsertUpdate(null);
        }

        //---------------------------------------------------------------------------------------------

        public int InsertUpdate(SqlTransaction transaction)
        {
            const string spName = "p_SHARE_Attachment_InsertUpdate";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@ID", SqlDbType.Int, ID);
            db.AddInParameter(dbCommand, "@ModuleID", SqlDbType.UniqueIdentifier, ModuleID);
            db.AddInParameter(dbCommand, "@ItemID", SqlDbType.Int, ItemID);
            db.AddInParameter(dbCommand, "@FileName", SqlDbType.NVarChar, FileName);
            db.AddInParameter(dbCommand, "@FileUrl", SqlDbType.NVarChar, FileUrl);
            db.AddInParameter(dbCommand, "@FileSize", SqlDbType.BigInt, FileSize);
            db.AddInParameter(dbCommand, "@ContentType", SqlDbType.VarChar, ContentType);
            db.AddInParameter(dbCommand, "@StorageType", SqlDbType.VarChar, StorageType);
            db.AddInParameter(dbCommand, "@BinaryContent", SqlDbType.VarBinary, BinaryContent);

            if (transaction != null)
                return db.ExecuteNonQuery(dbCommand, transaction);
            else
                return db.ExecuteNonQuery(dbCommand);
        }

        //---------------------------------------------------------------------------------------------
        public static bool InsertUpdateCollection(IList<Attachment> collection)
        {
            bool ret;
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            using (SqlConnection connection = (SqlConnection)db.CreateConnection())
            {
                connection.Open();
                using (SqlTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        bool ret01 = true;
                        foreach (Attachment item in collection)
                        {
                            if (item.InsertUpdate(transaction) <= 0)
                            {
                                ret01 = false;
                                break;
                            }
                        }
                        if (ret01)
                        {
                            transaction.Commit();
                            ret = true;
                        }
                        else
                        {
                            transaction.Rollback();
                            ret = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw new Exception("Error at InsertUpdateCollection method: " + ex.Message);

                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
            return ret;
        }
        #endregion

        //---------------------------------------------------------------------------------------------

        #region Update methods.

        public static int UpdateAttachment(int id, Guid moduleID, int itemID, string fileName, string fileUrl, long fileSize, string contentType, string storageType, byte[] binaryContent)
        {
            Attachment entity = new Attachment();
            entity.ID = id;
            entity.ModuleID = moduleID;
            entity.ItemID = itemID;
            entity.FileName = fileName;
            entity.FileUrl = fileUrl;
            entity.FileSize = fileSize;
            entity.ContentType = contentType;
            entity.StorageType = storageType;
            entity.BinaryContent = binaryContent;
            return entity.Update();
        }

        //---------------------------------------------------------------------------------------------

        public int Update()
        {
            return this.Update(null);
        }

        //---------------------------------------------------------------------------------------------

        public int Update(SqlTransaction transaction)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_Update]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@ID", SqlDbType.Int, ID);
            db.AddInParameter(dbCommand, "@ModuleID", SqlDbType.UniqueIdentifier, ModuleID);
            db.AddInParameter(dbCommand, "@ItemID", SqlDbType.Int, ItemID);
            db.AddInParameter(dbCommand, "@FileName", SqlDbType.NVarChar, FileName);
            db.AddInParameter(dbCommand, "@FileUrl", SqlDbType.NVarChar, FileUrl);
            db.AddInParameter(dbCommand, "@FileSize", SqlDbType.BigInt, FileSize);
            db.AddInParameter(dbCommand, "@ContentType", SqlDbType.VarChar, ContentType);
            db.AddInParameter(dbCommand, "@StorageType", SqlDbType.VarChar, StorageType);
            db.AddInParameter(dbCommand, "@BinaryContent", SqlDbType.VarBinary, BinaryContent);

            if (transaction != null)
                return db.ExecuteNonQuery(dbCommand, transaction);
            else
                return db.ExecuteNonQuery(dbCommand);
        }

        //---------------------------------------------------------------------------------------------
        public static bool UpdateCollection(IList<Attachment> collection)
        {
            bool ret;
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            using (SqlConnection connection = (SqlConnection)db.CreateConnection())
            {
                connection.Open();
                using (SqlTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        bool ret01 = true;
                        foreach (Attachment item in collection)
                        {
                            if (item.Update(transaction) <= 0)
                            {
                                ret01 = false;
                                break;
                            }
                        }
                        if (ret01)
                        {
                            transaction.Commit();
                            ret = true;
                        }
                        else
                        {
                            transaction.Rollback();
                            ret = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw new Exception("Error at UpdateCollection method: " + ex.Message);
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
            return ret;
        }

        #endregion

        //---------------------------------------------------------------------------------------------

        #region Delete methods.

        public static int DeleteAttachment(int id)
        {
            Attachment entity = new Attachment();
            entity.ID = id;

            return entity.Delete();
        }

        public int Delete()
        {
            return this.Delete(null);
        }

        //---------------------------------------------------------------------------------------------

        public int Delete(SqlTransaction transaction)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_Delete]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@ID", SqlDbType.Int, ID);

            if (transaction != null)
                return db.ExecuteNonQuery(dbCommand, transaction);
            else
                return db.ExecuteNonQuery(dbCommand);
        }

        //---------------------------------------------------------------------------------------------


        public static int DeleteDynamic(string whereCondition)
        {
            const string spName = "[dbo].[p_SHARE_Attachment_DeleteDynamic]";
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            SqlCommand dbCommand = (SqlCommand)db.GetStoredProcCommand(spName);

            db.AddInParameter(dbCommand, "@WhereCondition", SqlDbType.NVarChar, whereCondition);

            return db.ExecuteNonQuery(dbCommand);
        }
        //---------------------------------------------------------------------------------------------

        public static bool DeleteCollection(IList<Attachment> collection)
        {
            bool ret;
            SqlDatabase db = (SqlDatabase)DatabaseFactory.CreateDatabase();
            using (SqlConnection connection = (SqlConnection)db.CreateConnection())
            {
                connection.Open();
                using (SqlTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        bool ret01 = true;
                        foreach (Attachment item in collection)
                        {
                            if (item.Delete(transaction) <= 0)
                            {
                                ret01 = false;
                                break;
                            }
                        }
                        if (ret01)
                        {
                            transaction.Commit();
                            ret = true;
                        }
                        else
                        {
                            transaction.Rollback();
                            ret = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw new Exception("Error at DeleteCollection method: " + ex.Message);
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
            return ret;
        }
        #endregion
    }
}